package functionalInterface;

import java.util.function.Predicate;

/**
    Predicate<T>接口,作用:对某种数据类型的数据进行判断,结果返回一个boolean值

    Predicate接口中包含抽象方法：
        boolean test(T t):用来对指定数据类型数据进行判断的方法
        boolean and(Predicate<? super T> other) : 并且(&&)判断的方法
        boolean or(Predicate<? super T> other) : 或者(||)判断的方法
        boolean Predicate<T> negate() : 取反(!)判断的方法
*/
public class Demo07Predicate {

    public static void main(String[] args) {

        /*---Predicate--=test方法---------------*/
        //定义一个字符串
        String s = "abcdef";
        //调用checkString方法对字符串进行校验,参数传递字符串和Lambda表达式
        /*boolean b = checkString(s,(String str)->{
            //对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回
            return str.length()>5;
        });*/
        //优化Lambda表达式
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);   //true

        /*---Predicate--=and方法---------------*/
        //调用checkString方法,参数传递字符串和两个Lambda表达式
        boolean c = checkString(s,(String str)->{
            //判断字符串的长度是否大于5
            return str.length()>5;
        },(String str)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(c);  //true

        /*---Predicate--=or方法---------------*/
        //调用checkString方法,参数传递字符串和两个Lambda表达式
        boolean d = checkString1(s,(String str)->{
            //判断字符串的长度是否大于5
            return str.length()>5;
        },(String str)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(d);

        /*---Predicate--=or方法---------------*/
        boolean e = checkString1(s,(String str)->{
            //判断字符串的长度是否大于5,并返回结果
            return str.length()>5;
        });
        System.out.println(e);
    }


    /**
     * 使用Predicate中的方法test对字符串进行判断,并把判断的结果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return  pre.test(s);
    }

    /**
     * Predicate接口中有一个方法and,表示并且关系,也可以用于连接两个判断条件
     *     方法内部的两个判断条件,也是使用&&运算符连接起来的
     */
    public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);  //等价于return pre1.test(s) && pre2.test(s);
    }

    /**
     *   Predicate接口中有一个方法or,表示或者关系,也可以用于连接两个判断条件
     */
    public static boolean checkString1(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) || pre2.test(s);
        return  pre1.or(pre2).test(s);   //等价于return pre1.test(s) || pre2.test(s);
    }

    /**
     *  Predicate接口中有一个方法negate,也表示取反的意思
     */
    public static boolean checkString1(String s, Predicate<String> pre){
        //return !pre.test(s);
        return  pre.negate().test(s);//等效于return !pre.test(s);
    }
}
